vector3D.toString()->byte[40]
Klasse: vector3D
Wandelt einen 3D-Vektor in einen String um.
v = vector3D(x=24,y=32,z=11)
v.toString() # => "[24.000000:32.000000:11.000000]"
vector3D.cross(v:vector3D)->vector3D
Klasse: vector3D
Berechnet das Kreuzprodukt des 3D-Vektors mit dem übergebenen 3D-Vektor v.
Das Resultat bei einem Kreuzprodukt ist ein neuer 3D-Vektor.
vector3D.dot(v:vector3D)->float
Klasse: vector3D
Berechnet das Skalarprodukt des 3D-Vektors mit dem übergebenen 3D-Vektor v.
vector3D.distance(v:vector3D)->float
Klasse: vector3D
Berechnet die Distanz zwischen zwei 3D-Vektoren.
vector3D.magnitude()->float
Klasse: vector3D
Berechnet die Länge des 3D-Vektors.
vector3D.random()
Klasse: vector3D
Erzeugt einen zufälligen 3D-Richtungsvektor mit Länge 1.
vector3D.fromAngle(alpha:float, theta:float)
Klasse: vector3D
Erzeugt einen normalisierten 3D-Vektor mit der Richtung alpha und theta in Radiant.
vector3D.mulScalar(s:float)
Klasse: vector3D
Multipliziert den Wert s mit den x-, y- und z-Werten des 3D-Vektors (Skalar-Multiplikation)
v1 = vector(x=4,y=8,z=2)
v1.mulScalar(10)
vector3D.subScalar(s:float)
Klasse: vector3D
Subtrahiert den Wert s von den x-, y- und z-Werten des 3D-Vektors (Skalar-Subtraktion)
v1 = vector3D(x=4,y=8,z=2)
v1.subScalar(10)
vector3D.addScalar(s:float)
Klasse: vector3D
Addiert den Wert s zu den x-, y- und z-Werten des 3D-Vektors (Skalar-Addition)
v1 = vector3D(x=4,y=8,z=2)
v1.addScalar(10)
vector3D.sub(v:vector3D)
Klasse: vector3D
Subtrahiert den 3D-Vektor v vom 3D-Vektor
v1 = vector3D(x=4,y=8,z=2)
v2 = vector3D(x=3.5,y=1.8,z=1.1)
v1.sub(v2)
vector3D.add(v:vector3D)
Klasse: vector3D
Addiert den 3D-Vektor v zum 3D-Vektor.
v1 = vector3D(x=4,y=8,z=2)
v2 = vector3D(x=3.5,y=1.8,z=1.1)
v1.add(v2)
vector3D.normalize()
Klasse: vector3D
Normalisiert den 3D-Vektor. Dies bedeutet, dass nach dem Aufruf die Vektorlänge 1 ist.
v = vector3D(x=5,y=10,z=3)
v.normalize()
vector.toString()->byte[30]
Klasse: vector
Wandelt einen Vektor in einen String um.
v = vector(x=24,y=32)
v.toString() # => "[24.000000:32.000000]"
vector.limit(xMin:float, xMax:float, yMin:float, yMax:float)
Klasse: vector
Limitiert den Vektor an den definierten Bereich (xMin… xMax & yMin… yMax).
vector.limitToScreen(offset:int)
Klasse: vector
Limitiert den Vektor an den sichtbaren Bildschirmbereich (0… 239).
Wahlweise kann ein Offset grösser als 0 gewählt werden um den sichtbaren Bereich zu verkleinern.
v = vector(x=-5,y=250)
v.limitToScreen(0)
v.x # => 0
v.y # => 239
v.limitToScreen(5)
v.x # => 5
v.y # => 234
vector.dot(v:vector)->float
Klasse: vector
Berechnet das Skalarprodukt des Vektors mit dem übergebenen Vektor v.
vector.angle()->float
Klasse: vector
Liefert den Winkel in Radiant des Vektors.
vector.distance(v:vector)->float
Klasse: vector
Berechnet die Distanz zwischen zwei Vektoren.
vector.magnitude()->float
Klasse: vector
Berechnet die Länge des Vektors.
vector.random()
Klasse: vector
Erzeugt einen zufälligen Richtungsvektor mit Länge 1.
Das folgende Beispiel zeichnet 3000 zufällige Vektoren mit jeweils einer zufälligen Länge zwischen 0 und 100 Pixel und einer unterschiedlichenn Helligkeit.
for i in 3000:
v:vector
v.random()
v.mulScalar(random(0,100))
strokeHSV(110,255,random(0,255))
drawLine(120,120,120+v.x,120+v.y)
update()
vector.fromAngle(angle:float)
Klasse: vector
Erzeugt einen normalisierten Vektor mit der Richtung angle in Radiant.
Das folgende Beispiel zeichnet 12 Kreise u einen Kreis.
2*PI ist der Kreisumfang im Einheitskreis. Diesen teilen wir in 12 Teile und initialisieren damit den die Vektorrichtung. Mit mulScalar(..) verändern wir dann die Länge des Vektors, welche dem Radius des Kreises entspricht.
for i in 12:
f = PI/6*i
v:vector
v.fromAngle(f)
v.mulScalar(80)
drawCircle(120+v.x,120+v.y,5)
update()
vector.subScalar(s:float)
Klasse: vector
Subtrahiert den Wert s zu je von den x- und y-Werten des Vektors (Skalar-Subtraktion)
v1 = vector(x=4,y=8)
v1.subScalar(10)
vector.mulScalar(s:float)
Klasse: vector
Multipliziert den Wert s je mit den x- und y-Werten des Vektors (Skalar-Multiplikation)
v1 = vector(x=4,y=8)
v1.mulScalar(10)
vector.addScalar(s:float)
Klasse: vector
Addiert den Wert s zu je zu den x- und y-Werten des Vektors (Skalar-Addition)
v1 = vector(x=4,y=8)
v1.addScalar(10)
vector.sub(v:vector)
Klasse: vector
Subtrahiert den Vektor v vom Vektor
v1 = vector(x=4,y=8)
v2 = vector(x=3.5,y=1.8)
v1.sub(v2)
vector.normalize()
Klasse: vector
Normalisiert den Vektor. Dies bedeutet, dass nach dem Aufruf die Vektorlänge 1 ist.
v = vector(x=5,y=10)
v.normalize()
vector.add(v:vector)
Klasse: vector
Addiert den Vektor v zum Vektor
v1 = vector(x=4,y=8)
v2 = vector(x=3.5,y=1.8)
v1.add(v2)